home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / encodings / utf_32.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2014-12-31  |  5KB  |  149 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. """
  5. Python 'utf-32' Codec
  6. """
  7. import codecs
  8. import sys
  9. encode = codecs.utf_32_encode
  10.  
  11. def decode(input, errors = 'strict'):
  12.     return codecs.utf_32_decode(input, errors, True)
  13.  
  14.  
  15. class IncrementalEncoder(codecs.IncrementalEncoder):
  16.     
  17.     def __init__(self, errors = 'strict'):
  18.         codecs.IncrementalEncoder.__init__(self, errors)
  19.         self.encoder = None
  20.  
  21.     
  22.     def encode(self, input, final = False):
  23.         if self.encoder is None:
  24.             result = codecs.utf_32_encode(input, self.errors)[0]
  25.             if sys.byteorder == 'little':
  26.                 self.encoder = codecs.utf_32_le_encode
  27.             else:
  28.                 self.encoder = codecs.utf_32_be_encode
  29.             return result
  30.         return None.encoder(input, self.errors)[0]
  31.  
  32.     
  33.     def reset(self):
  34.         codecs.IncrementalEncoder.reset(self)
  35.         self.encoder = None
  36.  
  37.     
  38.     def getstate(self):
  39.         if self.encoder is None:
  40.             return 2
  41.  
  42.     
  43.     def setstate(self, state):
  44.         if state:
  45.             self.encoder = None
  46.         elif sys.byteorder == 'little':
  47.             self.encoder = codecs.utf_32_le_encode
  48.         else:
  49.             self.encoder = codecs.utf_32_be_encode
  50.  
  51.  
  52.  
  53. class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  54.     
  55.     def __init__(self, errors = 'strict'):
  56.         codecs.BufferedIncrementalDecoder.__init__(self, errors)
  57.         self.decoder = None
  58.  
  59.     
  60.     def _buffer_decode(self, input, errors, final):
  61.         if self.decoder is None:
  62.             (output, consumed, byteorder) = codecs.utf_32_ex_decode(input, errors, 0, final)
  63.             if byteorder == -1:
  64.                 self.decoder = codecs.utf_32_le_decode
  65.             elif byteorder == 1:
  66.                 self.decoder = codecs.utf_32_be_decode
  67.             elif consumed >= 4:
  68.                 raise UnicodeError('UTF-32 stream does not start with BOM')
  69.             return (output, consumed)
  70.         return None.decoder(input, self.errors, final)
  71.  
  72.     
  73.     def reset(self):
  74.         codecs.BufferedIncrementalDecoder.reset(self)
  75.         self.decoder = None
  76.  
  77.     
  78.     def getstate(self):
  79.         state = codecs.BufferedIncrementalDecoder.getstate(self)[0]
  80.         if self.decoder is None:
  81.             return (state, 2)
  82.         addstate = None(sys.byteorder == 'big' != (self.decoder is codecs.utf_32_be_decode))
  83.         return (state, addstate)
  84.  
  85.     
  86.     def setstate(self, state):
  87.         codecs.BufferedIncrementalDecoder.setstate(self, state)
  88.         state = state[1]
  89.         if state == 0:
  90.             self.decoder = codecs.utf_32_be_decode if sys.byteorder == 'big' else codecs.utf_32_le_decode
  91.         elif state == 1:
  92.             self.decoder = codecs.utf_32_le_decode if sys.byteorder == 'big' else codecs.utf_32_be_decode
  93.         else:
  94.             self.decoder = None
  95.  
  96.  
  97.  
  98. class StreamWriter(codecs.StreamWriter):
  99.     
  100.     def __init__(self, stream, errors = 'strict'):
  101.         self.encoder = None
  102.         codecs.StreamWriter.__init__(self, stream, errors)
  103.  
  104.     
  105.     def reset(self):
  106.         codecs.StreamWriter.reset(self)
  107.         self.encoder = None
  108.  
  109.     
  110.     def encode(self, input, errors = 'strict'):
  111.         if self.encoder is None:
  112.             result = codecs.utf_32_encode(input, errors)
  113.             if sys.byteorder == 'little':
  114.                 self.encoder = codecs.utf_32_le_encode
  115.             else:
  116.                 self.encoder = codecs.utf_32_be_encode
  117.             return result
  118.         return None.encoder(input, errors)
  119.  
  120.  
  121.  
  122. class StreamReader(codecs.StreamReader):
  123.     
  124.     def reset(self):
  125.         codecs.StreamReader.reset(self)
  126.         
  127.         try:
  128.             del self.decode
  129.         except AttributeError:
  130.             pass
  131.  
  132.  
  133.     
  134.     def decode(self, input, errors = 'strict'):
  135.         (object, consumed, byteorder) = codecs.utf_32_ex_decode(input, errors, 0, False)
  136.         if byteorder == -1:
  137.             self.decode = codecs.utf_32_le_decode
  138.         elif byteorder == 1:
  139.             self.decode = codecs.utf_32_be_decode
  140.         elif consumed >= 4:
  141.             raise UnicodeError, 'UTF-32 stream does not start with BOM'
  142.         return (object, consumed)
  143.  
  144.  
  145.  
  146. def getregentry():
  147.     return codecs.CodecInfo(name = 'utf-32', encode = encode, decode = decode, incrementalencoder = IncrementalEncoder, incrementaldecoder = IncrementalDecoder, streamreader = StreamReader, streamwriter = StreamWriter)
  148.  
  149.